home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume89 / workbnch / flist12.1 next >
Internet Message Format  |  1989-03-15  |  56KB
  1. Path: xanth!ames!mailrus!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v89i049:  flist - scrollable cli and directory lister v1.2, Part01/03
  5. Message-ID: <12228@swan.ulowell.edu>
  6. Date: 15 Mar 89 17:21:12 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 1956
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: alliant!mistress!berry (Steve -Raz- Berry)
  12. Posting-number: Volume 89, Issue 49
  13. Archive-name: workbench/flist12.1
  14.  
  15. Flist is a scrollable interactive CLI and list environment. I wrote it
  16. because the Dirutils were too inflexible for my tastes, and the CLI doesn't
  17. have a scroll bar. There are tons of features, some of which are:
  18.  
  19.     * Support for both the Workbench or the CLI.
  20.     * Change directory and parent directory.
  21.     * Delete file or directory.
  22.     * Sort list by name, time, file size, day or pattern.
  23.     * ARP filerequestor for changing directory across devices.
  24.     * Help synopsis via the Help key.
  25.     * Even an AREXX port.
  26.  
  27. and much, much more.  The NULL: device handler which although not
  28. required, is heavily recommended.
  29.  
  30. Written by Stephen (Raz) Berry. Comments and suggestions are most welcome.
  31. This is Version 1.2 , Many additions and changes since 1.1.
  32.  
  33. If you have any comments, additions or bug reports please forward them to
  34. BIX:    razberry
  35. UUCP:   ...alliant!mistress!amiga
  36.  
  37. #    This is a shell archive.
  38. #    Remove everything above and including the cut line.
  39. #    Then run the rest of the file through sh.
  40. #----cut here-----cut here-----cut here-----cut here----#
  41. #!/bin/sh
  42. # shar:    Shell Archiver
  43. #    Run the following text with /bin/sh to create:
  44. #    Flist.doc
  45. #    arpdos.asyncrun
  46. #    arpdos.c
  47. #    display.c
  48. #    dos.c
  49. #    errout.c
  50. #    fl.flex
  51. #    flist.c
  52. #    flist.h
  53. #    flist.icon.c
  54. #    flist.icon.uu
  55. #    help.c
  56. #    iconify.c
  57. #    iconify.h
  58. #    makefile
  59. #    misc.c
  60. # This archive created: Wed Mar 15 12:11:39 1989
  61. cat << \SHAR_EOF > Flist.doc
  62. NAME
  63.  
  64.     flist - file lister and sorting utility
  65.  
  66. SYNOPSIS
  67.  
  68.     flist [directory] [FROM file] [?]
  69.  
  70. DESCRIPTION
  71.  
  72.     Flist will display files as given on the command line, or if there
  73.     are no arguments the current directory. Flist allows  commands to 
  74.     be executed as if they were typed at a CLI. The list of files may
  75.     be sorted by name, time, size or by a pattern. Most of flist's commands
  76.     are control sequences as defined below.
  77.  
  78.     You may also specify the name of a file that contains file names to 
  79.     be displayed by flist.
  80.  
  81.     Control sequences are indicated by the '^' character preceding an
  82.     uppercase letter. To invoke the command from flist it is not necessary
  83.     to capitilize the letter. You may also use the Menu shortcuts, which
  84.     for the most part follow the same lettering scheme as the control 
  85.     sequences (but check first).
  86.  
  87.     ^A - Invoke the ARP filerequestor. The ARP filerequestor will appear on
  88.     the flist screen starting at the RAM: directory. All that is required
  89.     is for the user to select a directory for flist to display. By clicking
  90.     on the right mouse button, you can get a list of devices in the system.
  91.     When the directory that is desired is displayed by the requestor, then
  92.     select the OK button. If you want to abort the operation then select
  93.     the CANCEL button.
  94.  
  95.     ^C - Abort flist. If you want to terminate flist from the keyboard,
  96.     typing control-c will bring up a requestor to make sure that this is
  97.     what you want to do. (HINT: hitting A-v will select the OK button)
  98.  
  99.     ^D - Change directory. (Refer to the diagram below) To change directory
  100.     place the cursor opposite a 'Dir' entry in flist using the cursor keys
  101.     (input area 6). Typing control-d at this time will change directory 
  102.     to the left (Directory1) of the input area.
  103.  
  104.  
  105.     ---------------------------------------------------------------------
  106.     | Current directory   Files = 10                                    |
  107.     ---------------------------------------------------------------------
  108.     | filename1     |                   | date  time    filesize        |
  109.     | filename2     |                   | date  time    filesize        |
  110.     | filename3     |                   | date  time    filesize        |
  111.     | filename4     |                   | date  time    filesize        |
  112.     | filename5     |                   | date  time    filesize        |
  113.     | Directory1    | ^D                | date  time     Dir            |
  114.     | filename7     |                   | date  time    filesize        |
  115.     | filename8     |                   | date  time    filesize        |
  116.     | filename9     |                   | date  time    filesize        |
  117.     | filename10    |                   | date  time    filesize        |
  118.                         ^^input area
  119.  
  120. and so on...
  121.  
  122.     ^K - Kill (delete) file. By placing the cursor to the right of the filename
  123.     that is to be deleted (also directories) and typing control-k, the 
  124.     filename will be deleted from the media.
  125.     
  126.     ^L - Restore screen. This command redraws the entire screen. It also
  127.     resets all the internal pointers to the top of the list.
  128.  
  129.     ^N - Make new directory. A string requestor will appear, prompting
  130.     you to enter the name of the new directory. Hitting return with
  131.     no entry in the requestor will do nothing.
  132.  
  133.     ^P - Get parent directory. Typing the sequence control-p will force
  134.     flist to go up the file structure one level.
  135.  
  136.     ^R - Rename file/directory. A string requestor will prompt you to enter
  137.     the new file. The cursor will continue to be displayed to indicate the
  138.     file that is to be changed. Hitting return with no entry in the requestor
  139.     will do nothing.
  140.  
  141.     ^S - Sort the filenames and directories alphabetically.
  142.  
  143.     ^Z - Sort the filenames by size. Directories will be listed first.
  144.  
  145.     ^Y - Sort the filenames by the day created.
  146.  
  147.     ^T - Sort the filenames and directories by creation TIME.
  148.  
  149.     ^O - Sort the filenames by pattern. A string requestor will promt you
  150.     to enter the pattern to sort the current list by. Hitting return with
  151.     no entry in the requestor will do nothing. Entering a pattern will
  152.     exclude all entries in the list except those that match the pattern.
  153.     Patterns may be standard AmigaDOS or ARP wildcards.
  154.  
  155.     ^G - Re-get the current directory. Useful if you move or sort the
  156.     files, and you want Flist to be operating on current information.
  157.  
  158.     ^U - Erase the contents of the current line and place the cursor at 
  159.     the beginning of the input area.
  160.     
  161.     ^X - Invoke an Flist AREXX macro. A string requestor will prompt you
  162.     to enter the macro name. Hitting return with no entry in the requestor
  163.     will do nothing.
  164.  
  165.     Help key - Hitting the help key will give you a synopsis of the 
  166.     keyboard control commands. Type any key on the main keyboard (make 
  167.     sure the help window is activated) to get rid of the help window.
  168.  
  169.     SHIFT-UP - Holding the shift key down and pressing the up arrow key
  170.     will move the list up by 10 lines (if possible).
  171.  
  172.     SHIFT-DOWN - Holding the shift key down and pressing the down arrow key
  173.     will move the list down by 10 lines (if possible).
  174.  
  175.     SHIFT-LEFT - Holding the shift key down and pressing the left arrow key
  176.     will move the cursor to the first character on the typed line.
  177.  
  178.     SHIFT-RIGHT - Holding the shift key down and pressing the right arrow key
  179.     will move the cursor to the last character on the typed line.
  180.  
  181.     INPUT AREA:
  182.  
  183.         The input area provides a powerful tool for the lazy typist (me).
  184.         As an example, say you want to copy two files to another directory.
  185.         First type the command 'copy ' on any line, then place the cursor 
  186.         opposite the first file to copy (using the up and down arrow keys)
  187.         and then press the Esc key. The file name will be inserted into the 
  188.         input area. Then to get the second file name, move the cursor again
  189.         to the line opposite the second file name and press the Esc key again.
  190.         Then type the volume or directory path for the files destination and 
  191.         hit return to execute the command. Flist will update the line/screen
  192.         as the cursor moves up or down the display.
  193.  
  194.     If the command is larger than the input area, then Flist will scroll
  195.     up to 90 characters to fit the input into the display.
  196.  
  197. AmigaDOS SUPPORT:
  198.  
  199.     Flist will execute any command that is typed in the input area
  200.     and in the current search path. To execute a command, type it in
  201.     with the correct path information, and hit return. Flist will open
  202.     a window for I/O (for those commands that require output or an inter-
  203.     active stream) and ask for you to hit return when the command has
  204.     finished execution.
  205.  
  206.     Many of the most usefull operations that can be performed on a directory
  207.     are included as standard functions in Flist. It is adviseable to use
  208.     these features instead of bypassing Flist and executing the command 
  209.     directly. In this way you can always be sure that list of files that are
  210.     displayed represent the true state of the directory. If you perform an
  211.     operation that does change the state of the directory, such as moving
  212.     a file to another directory, typing ^G (re-get directory) will re-initial-
  213.     ize the directory list.
  214.  
  215. AREXX SUPPORT:
  216.  
  217.     To initiate an Flist/AREXX macro program, select 'Execute REXX' from 
  218.     the menu. Or 'Ae' (left or right amiga and 'e') or even ^X (control-x)
  219.     to invoke the string requestor. The string requestor will prompt you 
  220.     to enter the macro name. If you are in the directory containing the 
  221.     supplied 'fl.flex' example, all you need type in the requestor is:
  222.  
  223.         'fl' and the return key (don't type the single quotes).
  224.         
  225.     You NEVER have to type the extension '.flex' when invoking a macro.
  226.  
  227.     Flist supports the following commands from the AREXX port. They are:
  228.  
  229.     'sort s'    - sort alphabetically.
  230.     'sort z'    - sort by size.
  231.     'sort t'    - sort by creation TIME.
  232.     'sort o'    - sort by pattern.
  233.     'sort y'    - sort by day.
  234.     'iconify'   - iconify Flist.
  235.     'end'       - tell Flist to stop listening to AREXX.
  236.     'parent'    - get the parent directory.
  237.     'redraw'    - redraw the screen.
  238.     'reget'     - reget the current directory.
  239.     'request'   - Bring up the ARP filerequestor.
  240.     'makedir'   - make a new directory.
  241.     'changedir "dirname"' - change to "dirname" directory.
  242.  
  243.     A more extensive command set is planned for the future.
  244.  
  245.     An Flist/AREXX macro must have the extension '.flex'.
  246.  
  247.     An Flist/AREXX macro must reside either in the current directory
  248.     or the REXX: logical directory.
  249.  
  250.     The line 'address "flport"' must preface any flist commands.
  251.  
  252.     If for some reason Flist is stuck waiting for a command from REXX
  253.     you can type this line (exactly) in another CLI to break the deadlock:
  254.  
  255.         rx "address 'flport' 'end'"
  256.  
  257.     See the supplied 'fl.flex' program for an example.
  258.  
  259. AUTHOR
  260.  
  261.     A lot of the code in Flist came from the public domain. That is the
  262.     primary reason Flist is PD, it's my way of saying thanks! The various
  263.     authors whose code fragments I borrowed are:
  264.     
  265.     Leo Schwab          -   iconify routines.
  266.     W.G.J. Langeveld    -   PathName routines.
  267.     Carolyn Schnepper   -   code stolen from timerwin.c
  268.  
  269.     My name is:  Steve (Raz) Berry. 
  270.  
  271.  I can be reached at:
  272.  
  273.     The Checkered Ball
  274.     A-7 Sinai Circle
  275.     Chelmsford, Ma. 01824
  276.     c/o Steve (Raz) Berry
  277.  
  278.     BIX: razberry
  279.     UUCP: ...alliant!mistress!amiga
  280.  
  281.     This is not a Shareware product. But don't let that stop you from sending
  282.     cash!
  283. SHAR_EOF
  284. cat << \SHAR_EOF > arpdos.asyncrun
  285. /* 
  286. **      This module is the workhorse of Flist.
  287. **      It is here that the commands typed in by the user are:
  288. **
  289. **      a: Scanned for special commands
  290. **      b: replaced for filename expansion
  291. **      c: prepped for ASyncRun
  292. **      d: Run as a Task.
  293. **
  294. */
  295.  
  296. #include <exec/types.h>
  297. #include <exec/nodes.h>
  298. #include <exec/lists.h>
  299. #include <exec/tasks.h>
  300. #include <exec/ports.h>
  301. #include <exec/io.h>
  302. #include <devices/console.h>
  303. #include <devices/inputevent.h>
  304. #include <intuition/intuition.h>
  305. #include <stdio.h>
  306. #include "libraries/arpbase.h"
  307. #include "flist.h"
  308.  
  309. struct ZombieMsg zombie;
  310. struct ProcessControlBlock PCB;
  311.  
  312. /* Some external variables here */
  313.  
  314. extern struct Window *winptr;
  315. extern int errno;
  316.  
  317. #define PCB_SETS PRF_SAVEIO|PRF_INTERACTIVE
  318.  
  319. long DoDOS(str)
  320. char *str;
  321. {
  322.         long ret;
  323.  
  324.         if (str[0] != 0) {
  325.                 ret = spawnproc(str);
  326.                 if (!ret)
  327.                         DisplayBeep(NULL);
  328.         }
  329. }
  330.  
  331. long spawnproc(str)
  332. char *str;
  333. {
  334.         long i, j, ret;
  335.         char command[90], args[90], buf[90];
  336.         struct ZombieMsg *reply;
  337.         struct MsgPort *port;
  338.         struct FileHandle *fh;
  339.                 
  340.         port = winptr->UserPort;
  341.  
  342.         fh = Open("CON:0/0/640/80/Flist at Work",MODE_NEWFILE);
  343.         if (fh == NULL) {
  344.                 auto_req(" I can't seem to Open CON:");
  345.                 return FALSE;
  346.         }
  347.  
  348.         zombie.zm_ExecMessage.mn_ReplyPort = port;
  349.         
  350.         PCB.pcb_StackSize = 10000;      /* Maybe this should be bigger? */
  351.         PCB.pcb_Pri = 0;                /* Everybody runs at 0 */
  352.         PCB.pcb_Control = PCB_SETS;
  353.         PCB.pcb_TrapCode = NULL;        /* Use the defaults */
  354.         PCB.pcb_Input = fh;
  355.         PCB.pcb_Output = fh;
  356.         PCB.pcb_LoadedCode = NULL;
  357.         PCB.pcb_LastGasp = &zombie;     /* I want to be told when the 
  358.                                            process dies */
  359.         PCB.pcb_WBProcess = NULL;
  360.         PCB.pcb_Console.pcb_SplatFile = fh;
  361.         PCB.pcb_Console.pcb_ConName = NULL;
  362.  
  363.         for(i=0;str[i] != ' ' && str[i] != '\0' && i < 89;i++)
  364.                         command[i] = str[i];
  365.  
  366.         command[i] = 0;
  367.  
  368.         /* Now if this isn't weird syntax, I don't know what is */
  369.  
  370.         if (str[i] == '\0') {
  371.                 args[0] = '\n';
  372.                 args[1] = '\0';
  373.         } else {
  374.                 ++i;
  375.                 for(j=0;str[j+i] != '\0' && (j-i < 89);j++)
  376.                                 args[j] = str[j+i];
  377.                 args[j] = '\0';
  378.         }
  379.  
  380. #ifdef DEBUG
  381.         sprintf(&buf[0],"Sending -%s- to Execute.",str);
  382.         SetWindowTitles(winptr,0L,buf);
  383. #endif
  384.    /*     ret = ASyncRun(&command[0], &args[0], &PCB); */
  385.    
  386.         ret = Execute(str,NULL,fh);
  387.         Delay(30L);
  388.         
  389.         if (!ret){
  390.                 sprintf(&buf[0],"*** ERROR *** Execute returns - %d", IoErr());
  391.                 SetWindowTitles(winptr,0L,buf);
  392.                 DisplayBeep(NULL);
  393.                 Close(fh);
  394.                 return FALSE;
  395.         } else {
  396. /*                reply = (struct ZombieMsg *)WaitPort(port); */
  397.  
  398.                 /* Wait for the user to terminate the window */
  399.  
  400.                 ret = Read(fh, buf, 1L);
  401.                 sprintf(&buf[0]," Task died with return of %d", ret);
  402.                 SetWindowTitles(winptr,0L,buf);
  403.                 Delay(30); 
  404.                 Close(fh);
  405.         }
  406. }SHAR_EOF
  407. cat << \SHAR_EOF > arpdos.c
  408. /* 
  409.         This module is the workhorse of Flist.
  410.         It is here that the commands typed in by the user are:
  411.   
  412.         a: Scanned for special commands
  413.         b: replaced for filename expansion
  414.         c: prepped for ASyncRun
  415.         d: Run as a Task.
  416.   
  417. */
  418.  
  419. #include <stdio.h>
  420. #include "flist.h"
  421.  
  422. /* Some external variables here */
  423.  
  424. extern struct Window *winptr;
  425. extern int errno;
  426. extern struct FileLock *lock;
  427. extern long mousey;
  428.  
  429. #define PCB_SETS PRF_SAVEIO|PRF_INTERACTIVE
  430.  
  431. long DoDOS(str)
  432. char *str;
  433. {
  434.     long ret;
  435.  
  436.     if (str[0] != 0) {
  437.             ret = spawnproc(str);
  438.             if (!ret)
  439.                     DisplayBeep(NULL);
  440.     }
  441.     return ret;
  442. }
  443.  
  444. long spawnproc(str)
  445. char *str;
  446. {
  447.         long i, j, ret, ret1, pnt;
  448.         char command[90], args[90], buf[1000], path[1000];
  449.         struct FileHandle *fh;
  450.  
  451.     /*  In case your wondering, I'm trying to put the window under the 
  452.         mouse. Why? Because I want to make it easy to kill it later! */
  453.  
  454.         i = (mousey > 119) ? 120: mousey;
  455.  
  456.         sprintf(buf,"CON:0/%d/640/80/Flist at Work", i);
  457.         fh = Open(buf,MODE_NEWFILE);
  458.         if (fh == NULL) {
  459.                 auto_req(" I can't seem to Open CON:");
  460.                 return FALSE;
  461.         }
  462.  
  463. /*  Here be the LARGEST Kluge I have ever run across in AmigaDOS...
  464.     Execute() must be fed the command 'cd current.directory' as part
  465.     of the string, if you expect to be executing out of the current
  466.     directory that is! */
  467.  
  468.         PathName(lock, path);
  469.         strcpy(buf, "cd \"");
  470.         strcat(buf, path);
  471.         pnt = strlen(buf);
  472.         strcat(buf, "\"\n");
  473.         strcat(buf, str); 
  474.  
  475. #ifdef DEBUG
  476.         sprintf(path,"Sending -%s- to Execute.",buf);
  477.         SetWindowTitles(winptr,-1L,path);
  478. #endif
  479.  
  480.         ret = Execute(buf,NULL,fh);
  481.         
  482.         if (!ret){
  483. #ifdef DEBUG 
  484.                 sprintf(&buf[0],"*** ERROR *** Execute returns - %ld", IoErr());
  485.                 SetWindowTitles(winptr,-1L,buf);
  486. #endif
  487.                 DisplayBeep(NULL);
  488.                 Close(fh);
  489.                 return FALSE;
  490.         } else {
  491.  
  492.         /* Wait for the user to terminate the window */
  493.  
  494.                 buf[0] = 0x9b;  buf[1] = 0x34;
  495.                 buf[2] = 0x30;  buf[3] = 0x3b;
  496.                 buf[4] = 0x33;  buf[5] = 0x33;
  497.                 buf[6] = 0x6d;  buf[7] = 0x0;
  498.                 strcat(buf, " Hit return to continue"); 
  499.                 Write(fh, buf, strlen(buf));
  500.                 ret1 = Read(fh, buf, 1L);
  501.                 Close(fh);
  502.         }
  503.         return TRUE;
  504. }
  505. SHAR_EOF
  506. cat << \SHAR_EOF > display.c
  507. /* 
  508.     This module contain all of the routines that interface directly with 
  509.     the display.
  510.  
  511.     Written by Steve (Raz) Berry.
  512. */
  513.  
  514. #include "flist.h"
  515. #include <libraries/arpbase.h>
  516. #include <stdio.h>
  517.  
  518. UWORD coltbl[8] = {
  519.     0x047, /* background color */
  520.     0xBBB, /* title text, inutuition boarders */
  521.     0xB15, /* gadget, title bar */
  522.     0x09B, /* Auto text */
  523.     0x0a0, /* Auto text */
  524.     0xC97, /* screen text */
  525.     0xfff, /* gadget selected*/
  526.     0x000  /* cursor */
  527. };
  528.  
  529. static struct Image   cc_img;
  530. static struct PropInfo   cc_prop = {AUTOKNOB | FREEVERT, 0,0, 0,0x1000,0,0,0,0,0,0 };
  531. struct Gadget pg = { NL,RWDTH-28,20,15,170,      /* Scroll Bar   */
  532.     GADGHCOMP,RELVERIFY | GADGIMMEDIATE | FOLLOWMOUSE, PROPGADGET,
  533.     (APTR)&cc_img,NL,NL,NL,(APTR)&cc_prop,FGAD,NL };
  534.  
  535. struct NewScreen scr = {
  536.     0,0,                /* x,y start */
  537.     640,200,            /* width, height */
  538.     2,                  /* depth */
  539.     2,1,                /* detail, block pens */
  540.     HIRES,              /* view mode */
  541.     WBENCHSCREEN,       /* screen type */
  542.     NULL,               /* font */
  543.     (UBYTE *) "Flist V1.2 - By Steve (Raz) Berry",         /* title */
  544.     NULL,               /* gadgets */
  545.     NULL                /* bitmap pntr */
  546.     };
  547.  
  548. struct NewWindow mywin = {
  549.     0,0,                        /* x,y start */
  550.     640,200,                    /* width, height */
  551.     2,1,                        /* detail, block pens */
  552.     RAWKEY | REFRESHWINDOW | GADGETDOWN | GADGETUP | MOUSEMOVE | 
  553.                                 /* IDCMP flags */
  554.     MOUSEBUTTONS | MENUPICK | REQCLEAR | SELECTDOWN | SELECTUP,
  555.     NORMALFLAGS,                /* window flags */
  556.     NULL, NULL,                 /* pntr gadget, checkmark */
  557.     (UBYTE *) "Flist",          /* title */
  558.     NULL,                   /* screen pointer filled in later (run time) */
  559.     NULL,                   /* bitmap pntr */
  560.     0, 0, 8000, 8000,       /* default x,y, &size */
  561.     CUSTOMSCREEN
  562.     };
  563.  
  564. /* Globals */
  565.  
  566. extern long numfiles, remember;
  567. extern long (*finfo[MAXDIR])[4];  /* miscelaneous info -- file size,blocks,dir type etc... */
  568. extern char (*fname[MAXDIR])[FCHARS];     /* file name and comment */
  569. extern char (*comm[MAXDIR])[FCHARS];
  570. extern char (*fstring[MAXDIR])[LEN_DATSTRING];
  571. extern char (*ftime[MAXDIR])[LEN_DATSTRING];
  572. extern struct Image cursor_image;
  573. extern long row,collum,line,first;
  574. extern struct Window *winptr;
  575. extern struct Screen *scrptr;
  576.  
  577. /* Globals defined here */
  578.  
  579. struct RastPort *rp;
  580.  
  581. /* Scrprt - print text to a screen (actually a rastport) */
  582.  
  583. scrprt(numb,top)
  584. short numb,top;
  585. {
  586.     struct IntuiText itext;
  587.     register long temp,i;
  588.  
  589.     if (top == remember )
  590.         return;
  591.         
  592.     /* for FAST movements of the screen... use the hardware */
  593.         
  594.     if ((top-remember) == 1 || (top-remember) == -1)
  595.         doBlit(top); 
  596.     else{
  597.         Move(rp,0,0);
  598.         ClearScreen(rp); 
  599.         if (numfiles != 0) {    /* Watch for empty directories! */
  600.             if (line > numfiles)
  601.                 temp = numfiles;
  602.             else
  603.                 temp = top;
  604.  
  605.             for(i=0;(i<numb)&&(i<NUMLINES);i++) {
  606.                 prtline(temp,i);
  607.                 if (temp < numfiles)
  608.                         temp++;
  609.             }
  610.         }
  611.     }
  612.     RefreshGadgets(&pg,winptr,NULL);
  613.     doborder();
  614.     remember = top;
  615. }
  616.  
  617. struct IntuiText itext = {
  618.         TEXTCOLOR, 0,
  619.         JAM2,
  620.         0,0,                    /* x, y */
  621.         NULL,                   /* font */
  622.         NULL,                   /* &text */
  623.         NULL,                   /* &next */
  624. };
  625.  
  626. /* Print a line associated with a file to the screen */
  627.  
  628. /* **** This could be optimized in assembly for speed **** */
  629.  
  630. prtline(pline,i)
  631. register long pline,i;
  632. {
  633.      char buffer[FCHARS];
  634.      struct BitMap *bmptr;
  635.  
  636.      if (pline >= numfiles)
  637.         return;
  638.      
  639.      bmptr = &scrptr->BitMap;
  640.  
  641.      itext.LeftEdge = 0;
  642.      itext.TopEdge = i * LINEH; 
  643.      strcpy(&buffer[0],fname[pline]);
  644.      buffer[13] = 0;
  645.      itext.IText = buffer; 
  646.      PrintIText(rp,&itext,3L,14L); 
  647.      itext.LeftEdge = 368; 
  648.      itext.IText = fstring[pline];
  649.      PrintIText(rp,&itext,3L,14L); 
  650.      itext.LeftEdge = 456; 
  651.      itext.IText = ftime[pline];
  652.      PrintIText(rp,&itext,3L,14L); 
  653.  
  654.      if (*finfo[pline][0] < 0)
  655.         sprintf(buffer,"%d         ",(*finfo[pline])[2]);
  656.      else
  657.         strcpy(buffer," Dir");
  658.  
  659.      itext.LeftEdge = 528; 
  660.      buffer[7] = 0;
  661.      itext.IText = buffer; 
  662.      PrintIText(rp,&itext,3L,14L); 
  663. }
  664.  
  665. doBlit(stop)
  666. long stop;
  667. {
  668.         long inter,i;        
  669.         struct BitMap *bmptr;
  670.         
  671.         inter = stop - remember;
  672.         bmptr = &scrptr->BitMap;
  673.  
  674.         WaitTOF();
  675.         if (inter > 0)
  676.                 ScrollRaster(rp,0L,LINEH,0L,(LONG)TOP+2,600L,189L);
  677. /*                    BltBitMap(bmptr,0L,22L,bmptr,0L,12L,600L,170L,
  678.                       (LONG)0x0c0,(LONG)0x0ff,tempblit); */
  679.         else
  680.                 ScrollRaster(rp,0L,-(LINEH),0L,(LONG)TOP+2,600L,189L);
  681. /*                    BltBitMap(bmptr,0L,12L,bmptr,0L,22L,600L,170L,
  682.                     (LONG)0x0c0,(LONG)0x0ff,tempblit); */
  683.         
  684.         if (inter > 0)
  685.                 prtline(stop+NLMO,NLMO);
  686.         else
  687.                 prtline(stop,0); 
  688. }
  689.  
  690. /* draw the border around the console display */
  691.  
  692. doborder()
  693. {
  694.         SetAPen(rp,3);
  695.         Move(rp,LEFT-2,TOP-1);
  696.         Draw(rp,RIGHT,TOP-1);
  697.         Draw(rp,RIGHT,BOT+1);
  698.         Draw(rp,LEFT-2,BOT+1);
  699.         Draw(rp,LEFT-2,TOP-1);
  700. }
  701.  
  702. /* this function captures the abort from cntrl c */
  703.  
  704. _abort()
  705. {
  706.     int ret;
  707.     ret = auto_req("User abort!!!");
  708.  
  709.     if(scrptr->FirstWindow->NextWindow != NULL) 
  710.         auto_req("Kill all other Applications first!");
  711.     else
  712.         if (ret) {
  713.             Cleanup();
  714.             exit(1);
  715.         }
  716.     menu();     /* no abort, go to the menu again! */
  717. }
  718.  
  719. openstuff()
  720. {
  721.     int i;
  722.     struct ViewPort *vp;
  723.  
  724.     scrptr = OpenScreen(&scr);
  725.     if (scrptr == NULL) {
  726.         fprintf(stderr,"Couldn't open Screen!\n");
  727.         FreeFlistMem();
  728.         exit(30L);
  729.     }
  730.  
  731.     mywin.FirstGadget = &pg;   /* prop gadget attached to the window */
  732.     mywin.Screen = scrptr;
  733.     winptr = OpenWindow(&mywin);
  734.     if (winptr == NULL) {
  735.         fprintf(stderr,"Couldn't open Window!\n");
  736.         FreeFlistMem();
  737.         CloseScreen(scrptr);
  738.         exit(40L);
  739.     }
  740.  
  741.     OpenConsole();
  742.     
  743.     rp = winptr->RPort;
  744.     vp = &scrptr->ViewPort;
  745.  
  746. /*     LoadRGB4(vp,&coltbl,4L); */
  747.  
  748.     refresh();
  749. }
  750. SHAR_EOF
  751. cat << \SHAR_EOF > dos.c
  752. /* 
  753.     This module contains routines that do things to AmigaDOS. Things
  754.     such as change directory, or parent directory or delete file etc...
  755. */
  756.  
  757. #include "libraries/arpbase.h"
  758. #include "flist.h"
  759.  
  760. struct Window *make_gadget();
  761. extern void refresh();
  762.  
  763. extern struct AnchorPath *ap;
  764. extern struct FileLock *startdir, *lock, *olddir;
  765. extern struct Window *winptr;
  766. extern long (*finfo[MAXDIR])[4];  
  767. extern char (*fname[MAXDIR])[FCHARS];
  768. extern char (*comm[MAXDIR])[FCHARS];
  769. extern char (*fstring[MAXDIR])[LEN_DATSTRING];
  770. extern char (*ftime[MAXDIR])[LEN_DATSTRING];
  771. extern long top, row, line, numfiles, lastsort;
  772. extern char titlestr[80];
  773.  
  774. extern int PathName();
  775. extern struct NewWindow strwin;
  776. extern char strbuf[256];
  777.  
  778. long rename_file(file)
  779. char *file;
  780. {
  781.     char buf[256];
  782.     struct Window *strptr;
  783.  
  784.     strbuf[0] = '\0';
  785.     strptr = make_gadget("Enter string to rename to");
  786.  
  787.     if (strptr == NULL) {
  788.         auto_req("Couldn't open Requestor!");
  789.         return BAD_COMMAND;
  790.     }
  791.  
  792.     drawcur();
  793.  
  794.     wait_for_event(strptr);
  795.  
  796.     blankcur();
  797.  
  798. #ifdef DEBUG
  799.     sprintf(buf,"string gadget is -%s-",strbuf);
  800.     auto_req(buf);
  801. #endif
  802.  
  803.     if (strbuf[0] == '\0')
  804.         return NULL;
  805.  
  806.     if (!Rename(file,strbuf)) {
  807.         auto_req("Couldn't rename file!");
  808.         return 1;
  809.     }
  810.  
  811.     strcpy(&fname[line][0],strbuf);
  812.  
  813.     return NULL;
  814. }
  815.  
  816. long make_dir()
  817. {
  818.     char buf[256];
  819.     long err;
  820.     struct FileLock *newlock;
  821.     struct Window *strptr;
  822.  
  823.     strbuf[0] = '\0';
  824.     strptr = make_gadget("Enter name of Directory ");
  825.  
  826.     if (strptr == NULL) {
  827.         auto_req("Couldn't open Requestor!");
  828.         return BAD_COMMAND;
  829.     }
  830.  
  831.     wait_for_event(strptr);
  832.  
  833.     if (strbuf[0] == '\0')
  834.         return NULL;
  835.  
  836.     newlock = CreateDir(strbuf);
  837.  
  838.     if (newlock == 0) {
  839.         err = IoErr();
  840.         sprintf(buf,"Couldn't Create directory! DOS error %ld",err);
  841.         auto_req(buf);
  842.         return 1;
  843.     } else
  844.         UnLock(newlock);
  845.  
  846.     getdir();
  847.  
  848.     return NULL;
  849. }
  850.  
  851. long changedir(str)
  852. char *str;
  853. {
  854.     char buf[1000], buf1[1000];
  855.     long rc;
  856.     struct FileLock *dummy;
  857.  
  858.     dummy = lock;
  859.     lock = Lock(str,ACCESS_READ);
  860.     if (lock == NULL){
  861.         lock = dummy;
  862.         sprintf(buf,"Can't Lock directory -%s-!",str);
  863.         auto_req(buf);
  864.         return DIR_LOCKED;
  865.     }
  866.  
  867.     strcpy(buf,str);
  868.     TackOn(buf, "*");
  869.  
  870.     rc = FindFirst(buf,ap); /* ARP does all the work getting the directory */
  871.  
  872.     if (rc == NULL){
  873.         Fillarray();    /* fill the arrays with the names and info */
  874.         top = 0;
  875.         row = 0;    
  876.         line = 0;
  877.     }
  878.     else {
  879.         if (rc != ERROR_NO_MORE_ENTRIES){
  880.             sprintf(buf,"Can't find directory -%s- !",str);
  881.             auto_req(buf);
  882.             return BAD_DIR;
  883.         } else
  884.             numfiles = 0;
  885.     }
  886.  
  887.     olddir = CurrentDir(lock);
  888.     
  889.     if (dummy != NULL)
  890.         UnLock(dummy);
  891.  
  892.     return rc;
  893. }
  894.  
  895. /* Go up one directory, saving all the locks */
  896.  
  897. parent()
  898. {
  899.     long rc;
  900.     char buf[1000], buf1[1000];
  901.     struct FileLock *dummy;
  902.  
  903.     if (lock == NULL)   /* if we are at the parent already -> return */
  904.         return;
  905.  
  906.                         /* Also watch for the root of the current volume */
  907.     PathName(lock, buf);
  908.     if (buf[strlen(buf)-1] == ':')
  909.         return;
  910.  
  911.     dummy = ParentDir(lock);
  912.     olddir = CurrentDir(dummy);
  913.  
  914.     if (lock != NULL)
  915.         UnLock(lock);
  916.  
  917.     lock = dummy;
  918.  
  919.     rc = FindFirst("*",ap); 
  920.  
  921.     if (rc == NULL) {
  922.         Fillarray();
  923.         top = 0;
  924.         row = 0;    
  925.         line = 0;
  926.     }
  927.     else 
  928.         auto_req("Can't change to Parent!");
  929. }
  930.  
  931. /* Delete (Kill) a file */
  932.  
  933. long kill(str)
  934. char *str;
  935. {
  936.     long rc,i;
  937.     char buf[1000];
  938.  
  939.     if (strlen(str) == 0 || numfiles == 0)
  940.         return BAD_COMMAND;
  941.  
  942.     rc = DeleteFile(str);
  943.  
  944.     if(rc == NULL) {
  945.         sprintf(buf,"Couldn't delete file %s",str);
  946.         auto_req(buf);
  947.         return BAD_COMMAND;
  948.     } else
  949.         numfiles--;
  950.         
  951.     for (i = line; i < numfiles;i++) {
  952.         swap(&finfo[i], &finfo[i+1]);
  953.         swap(&fname[i], &fname[i+1]);
  954.         swap(&comm[i], &comm[i+1]);
  955.         swap(&fstring[i], &fstring[i+1]);
  956.         swap(&ftime[i], &ftime[i+1]);
  957.     }
  958.     
  959.     return rc;
  960. }
  961.  
  962. /* 
  963.     Re-get the current directory... This is good for when the user renames
  964.     a file and wants to see the change in the list.
  965. */
  966.  
  967. getdir()
  968. {
  969.     long rc,i;
  970.     char buf[1000];
  971.  
  972.     rc = FindFirst("*",ap); 
  973.  
  974.     if (rc == NULL) {
  975.         Fillarray();    /* fill the arrays with the names and info */
  976.         top = 0;
  977.         row = 0;    
  978.         line = 0;
  979.     }
  980.     else {
  981.         if (rc != ERROR_NO_MORE_ENTRIES){
  982.             sprintf(buf,"Can't find current directory!");
  983.             auto_req(buf);
  984.             return BAD_DIR;
  985.         } else
  986.             numfiles = 0;
  987.     }
  988. }
  989.  
  990. /* swap two pointers */
  991.  
  992. swap(ptr1,ptr2)
  993. long *ptr1,*ptr2;
  994. {
  995.     long temp;
  996.     
  997.     temp = *ptr1;
  998.     *ptr1 = *ptr2;
  999.     *ptr2 = temp;
  1000. }
  1001. SHAR_EOF
  1002. cat << \SHAR_EOF > errout.c
  1003. /* 
  1004.     This module was created because of the need for error
  1005.     output when flist is 'run' or 'runback'ed.
  1006.     Because stderr is no a longer valid DOS filehandle, If flist
  1007.     detects an error and try's to output an error message to stderr,
  1008.     and we are running as a background task, the ouput to stderr will
  1009.     crash the machine. This is not user friendly. My solution is to
  1010.     open my own filehandle to stderr as a file in RAM:. While this 
  1011.     may not be the best solution, it will work in all cases that the
  1012.     ramdrive exists. If the ram: device is not available, then the output
  1013.     goes to NIL:.
  1014.     
  1015.     Drawbacks:
  1016.         You can never tell when you are run in the background, so you
  1017.         have to ALWAYS send output to this file.
  1018.  
  1019.     Written completely - I stole no code before it's time, by
  1020.         Stephen (Raz) Berry 1/2/89
  1021.  
  1022. */
  1023.  
  1024. #include <stdio.h>
  1025.  
  1026. Redirecterror(stderror)
  1027. struct FileHandle *stderror;
  1028. {
  1029.     struct FileHandle *newerror,*newout,*newin;
  1030.     
  1031.     newerror = freopen("RAM:flist.errors","a",stderr);
  1032.     newin = freopen("CON:0/0/1/1/DummyIO","a",stdin);
  1033.     newout = freopen("RAM:flist.out","a",stdout);
  1034.     
  1035.     if (newerror == NULL)
  1036.         newerror = freopen("NIL:","a",stderr);
  1037.  
  1038.     if (newin == NULL)
  1039.         newin = freopen("NIL:","a",stdin);
  1040.  
  1041.     if (newout == NULL)
  1042.         newout = freopen("NIL:","a",stdout);
  1043. }
  1044. SHAR_EOF
  1045. cat << \SHAR_EOF > fl.flex
  1046. /* 
  1047.     This is a test rexx macro prog for Flist!
  1048.  
  1049.     Here we test message passing between rexx and Flist. 
  1050.  
  1051.     NOTE: all commands that exist on their own lines and inclosed in 
  1052.     single quotes (optional) are passed to flist.
  1053.  
  1054.     Written by Stephen (Raz) Berry
  1055. */
  1056.  
  1057. trace off
  1058.  
  1059. address "flport"    /* Flist's port name */
  1060.  
  1061. norm = '9b34303b33316d'X    /* screen colors for highlights */
  1062. rever = '9b34303b33336d'X
  1063.  
  1064. if ~open(fd,'CON:0/80/640/30/Rexx_test') then exit(-30)
  1065. dummy = writeln(fd,rever || '  Prepare for Iconification!')
  1066. address command 'wait 3 sec'
  1067. dummy = close(fd)
  1068.  
  1069.  'iconify'  /* use Leo's iconify prog to shrink flist to an icon */
  1070.  
  1071. if ~open(fd,'CON:0/80/640/40/Rexx_test') then exit(-30)
  1072. dummy = writeln(fd,' This is what happens when you send a bad command.')
  1073. address command 'wait 3 sec'
  1074.  
  1075.  this is crapola  /* show what happens when a bad command is sent */
  1076.  
  1077. dummy = writeln(fd,'  Now we will sort the list by their file sizes!')
  1078. address command 'wait 3 sec'
  1079.  
  1080.  sort z   /* sort the list by size */
  1081.  
  1082. dummy = writeln(fd,'Now let us make a trip to the parent of this directory.')
  1083. address command 'wait 3 sec'
  1084.  
  1085.  parent   /* get the parent dir */
  1086.  
  1087. dummy = writeln(fd,'Pretend you have made a change to this directory.')
  1088. address command 'wait 2 sec'
  1089.  
  1090. dummy = writeln(fd,'Very Good. Now we can make Flist aware of the change.')
  1091. address command 'wait 2 sec'
  1092.  
  1093.  reget    /* reload the dir */
  1094.  
  1095. dummy = writeln(fd,'Now lets show off the pattern sorting ability of Flist.')
  1096. address command 'wait 2 sec'
  1097.  
  1098.  sort o
  1099.  
  1100. dummy = writeln(fd,'Like that? Now we will make a new directory.')
  1101. dummy = writeln(fd,'(Or you can hit return on a blank line to cancel)')
  1102. address command 'wait 2 sec'
  1103.  
  1104.  makedir
  1105.  
  1106. dummy = writeln(fd,'Assuming you are executing this macro from the flist')
  1107. dummy = writeln(fd,'directory we will change back to it now.')
  1108. address command 'wait 2 sec'
  1109.  
  1110.  changedir Flist
  1111.  
  1112. dummy = writeln(fd,'Now if you like you can use the ARP filerequestor to go')
  1113. dummy = writeln(fd,'to any volume your desire!')
  1114. address command 'wait 2 sec'
  1115.  
  1116.  request
  1117.  
  1118. dummy = writeln(fd,rever || '  Thats all Folks!')
  1119. address command 'wait 3 sec'
  1120. dummy = close(fd)
  1121.  
  1122. /* use the quotes here because END is a REXX keyword also */
  1123.  
  1124.  'end'      /* this should end the comunication, ...this is real helpful! */
  1125.  
  1126. exit
  1127. SHAR_EOF
  1128. cat << \SHAR_EOF > flist.c
  1129. /*
  1130.     This program was written by Stephen W. Berry.
  1131.  
  1132.     The concept is copyrighted by me, but the program listings
  1133.     executable and documentation are placed in the Public Domain.
  1134.  
  1135.     If you find a bug or enhance this program please let me know
  1136.     at the following address:
  1137.  
  1138.         The Checkered Ball
  1139.         A-7 Sinai Circle
  1140.         Chelmsford, Ma 01824
  1141.         c/o Stephen Berry
  1142.  
  1143. */
  1144.  
  1145. #define DEBUG TRUE
  1146.  
  1147. #include <rexx/storage.h>
  1148. #include <rexx/rxslib.h>
  1149. #include <libraries/arpbase.h>
  1150. #include <stdio.h>
  1151. #include "flist.h"
  1152.  
  1153. struct RxsLib *RexxSysBase = NULL;
  1154.  
  1155. /* external routines - system */
  1156.  
  1157. extern void CloseLibrary();
  1158. struct Screen *OpenScreen();
  1159. struct Window *OpenWindow();
  1160. struct IntuiMessage *GetMsg();
  1161.  
  1162. /* external routines - Arp */
  1163.  
  1164. extern void *ArpAlloc();
  1165.  
  1166. /* external routines - mine */
  1167.  
  1168. extern void menu(),tticon(),OpenConsole(),drawcur(),blankcur();
  1169. extern long parse();
  1170. extern void FreeFlistMem(),OpenRexxPort(),DeleteRexxPort(),CleanupRexx();
  1171. extern long OpenLib(),StartRexxProg();
  1172. extern struct RexxMsg *port,*PollRexxPort(),*WaitMsgPort();
  1173. extern void Redirecterror();
  1174.  
  1175. /* global variables, structures etc... */
  1176.  
  1177. extern struct IOStdReq ConsoleReq;
  1178. extern struct FileLock *startdir, *rootdir, *lock;
  1179. struct Screen *scrptr = NULL;
  1180. struct Window *winptr = NULL, *oldwinptr;
  1181. struct RexxMsg myrexxport;
  1182. extern long numfiles;
  1183.  
  1184. extern long (*finfo[MAXDIR])[4];
  1185. extern char (*fname[MAXDIR])[FCHARS];
  1186. extern char (*comm[MAXDIR])[FCHARS];
  1187. extern char (*fstring[MAXDIR])[LEN_DATSTRING];
  1188. extern char (*ftime[MAXDIR])[LEN_DATSTRING];
  1189. APTR oldcon;
  1190.  
  1191. struct Process *myproc;
  1192. long remember = -10;
  1193. int didRexx = FALSE;
  1194.  
  1195. main(argc,argv)
  1196. int argc;
  1197. char *argv[];
  1198. {
  1199.     struct IntuiMessage *msg;
  1200.     LONG i,rc = NULL;
  1201.  
  1202.     /* parse the command line and get the first file */
  1203.  
  1204.     if((rc = parse(argc,argv)) != NULL){
  1205.         printf("Input error.\n");
  1206.         printf("Flist requires the name(s) of files\n");
  1207.         printf("Or FROM and the name of a file with names in it.\n");
  1208.         printf("Standard DOS and ARP wildcards are accepted.\n");
  1209.         FreeFlistMem();
  1210.         Delay(20);
  1211.         exit(rc);
  1212.     }
  1213.  
  1214.     openstuff(); /* open the window and screen */
  1215.  
  1216. /*    myproc = (struct Process *)DeviceProc("flist"); */
  1217.     myproc = (struct Process *)FindTask(0L);
  1218. /*    myproc = (myproc != NULL) ? myproc - sizeof(struct Task): 0; */
  1219.  
  1220.     if (myproc != NULL){
  1221.  
  1222. /* Believe it or not, this stops ALL requestors from appearing! */
  1223.  
  1224.         oldwinptr = myproc->pr_WindowPtr;
  1225.         myproc->pr_WindowPtr = (struct Window *)(-1L); 
  1226.  
  1227. /* This allows a safer environment for flist's run in the background */
  1228.  
  1229.         oldcon = myproc->pr_ConsoleTask;
  1230.         myproc->pr_ConsoleTask = (struct Task *)DeviceProc("null:");
  1231.         myproc->pr_WindowPtr = winptr; 
  1232.         if (myproc->pr_ConsoleTask != NULL)
  1233.             freopen("NULL:","w+",stderr);
  1234.     }
  1235.  
  1236. /*  I link with arp.lib so that I don't have to open:
  1237.     intuition, graphics and arp libraries. */
  1238.  
  1239.     RexxSysBase = OpenLibrary("rexxsyslib.library",(LONG)RXSVERS);
  1240.  
  1241.     if (RexxSysBase != NULL) {
  1242.         OpenRexxPort("flport",&myrexxport);
  1243.         didRexx = TRUE;
  1244.     }
  1245.  
  1246.     menu();     /* we should never return ! */
  1247. }
  1248.  
  1249. Cleanup()
  1250. {
  1251.     int i;
  1252.  
  1253.     myproc->pr_WindowPtr = oldwinptr;
  1254.     myproc->pr_ConsoleTask = oldcon;
  1255.     if(didRexx)
  1256.         DeleteRexxPort(&myrexxport);
  1257.     if(RexxSysBase != NULL )
  1258.         CloseLibrary(RexxSysBase);
  1259.     FreeFlistMem();
  1260.     if(winptr != NULL)
  1261.         CloseDevice(&ConsoleReq);
  1262.         CloseWindowSafely(winptr,NULL);
  1263.     if(scrptr != NULL )
  1264.         CloseScreen(scrptr);
  1265.     UnLock(CurrentDir(startdir));       /* go back to the dir we started at */
  1266.  
  1267.     for (i=0;i<MAXDIR;i++)              /* free all array memory */
  1268.         if (fname[i] != 0) {
  1269.             FreeMem(fname[i],FCHARS);
  1270. /*            FreeMem(comm[i],FCHARS); */
  1271.             FreeMem(finfo[i],16L);
  1272.             FreeMem(fstring[i],LEN_DATSTRING);
  1273.             FreeMem(ftime[i],LEN_DATSTRING);
  1274.             fname[i] = 0;
  1275.             finfo[i] = 0;
  1276.             fstring[i] = 0;
  1277.             ftime[i] = 0;
  1278.         }
  1279. }
  1280. SHAR_EOF
  1281. cat << \SHAR_EOF > flist.h
  1282. /* 
  1283.     These are all the defines for Flist 
  1284. */
  1285.  
  1286. /* #define DEBUG */  /*  uncomment this line for debugging */
  1287.  
  1288. /* #define KILLEXTRA */ /* changes the way scrolling is done */
  1289.  
  1290. #define MAXDIR 1024
  1291. #define strcpy _BUILTIN_strcpy
  1292. #define NORMALFLAGS WINDOWSIZING|WINDOWDRAG|BORDERLESS|SMART_REFRESH|BACKDROP
  1293.  
  1294. #define FATALERROR      20L
  1295. #define DIR_LOCKED      1
  1296. #define BAD_DIR         2
  1297. #define BAD_COMMAND     1
  1298. #define OUT_OF_MEMORY   100L
  1299. #define CONVERSIONERROR 99L
  1300.  
  1301. #define TEXTCOLOR       5 
  1302. #define BACKGROUND      4
  1303. #define NL      NULL
  1304. #define RWDTH   640L
  1305. #define FGAD    0x76c0L
  1306. #define LEFT    114
  1307. #define RIGHT   363
  1308. #define TOP     12          /* Top of display */
  1309. #define BOT     192         /* Bottom of the display */
  1310. #define CHARW   8L          /* The width of each character */
  1311. #define LINEH   8L          /* This is the hieght of each line */
  1312. #define NUMLINES 22L        /* This is the number of lines in the display */
  1313. #define NLMO    21L         /* This stands for Num Lines Minus One */
  1314. #define MAXPLANES       3   /**  Max number of bitplanes we will need ***/
  1315. #define REDP    3
  1316. #define BLKP    2
  1317. #define WHTP    1
  1318. #define BLUP    0
  1319. #define FAST    MEMF_FAST|MEMF_CLEAR
  1320.  
  1321. #define LINESIZE        130L
  1322. #define INFOSIZE        16000
  1323. #define FILESIZE        LEN_DATSTRING*1000
  1324. #define COMMSIZE        LEN_DATSTRING*1000
  1325. #define STRINGSIZE      LEN_DATSTRING*1000
  1326. SHAR_EOF
  1327. cat << \SHAR_EOF > flist.icon.c
  1328. #include <exec/types.h>
  1329. #include <intuition/intuition.h>
  1330.  
  1331. UWORD   cursor_img[] = {
  1332.         0xffff,0xffff
  1333.         0xffff,0xffff
  1334.         0xffff,0xffff
  1335.         0xffff,0xffff
  1336.         0xffff
  1337.         };
  1338.  
  1339. UWORD               flist.icon_data[] = {
  1340.  
  1341.      /* BitPlane #0 */
  1342.  
  1343.      0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  1344.      0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC000, 
  1345.      0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC000, 
  1346.      0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC000, 
  1347.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1348.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1349.      0x7C1F, 0xE783, 0x8001, 0x800F, 0xC000, 
  1350.      0x7C0E, 0xE380, 0x0003, 0x800F, 0xC000, 
  1351.      0x7C0E, 0x0387, 0x87E7, 0xE00F, 0xC000, 
  1352.      0x7C0F, 0x8383, 0x8E03, 0x800F, 0xC000, 
  1353.      0x7C0E, 0x0383, 0x87C3, 0x800F, 0xC000, 
  1354.      0x7C0E, 0x0383, 0x80E3, 0xE00F, 0xC000, 
  1355.      0x7C1F, 0x07C7, 0xCFC1, 0xC00F, 0xC000, 
  1356.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1357.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1358.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1359.      0x7C00, 0x0000, 0x1E00, 0x000F, 0xC000, 
  1360.      0x7C00, 0x0000, 0x0E00, 0x000F, 0xC000, 
  1361.      0x7C00, 0x07EE, 0x7FC0, 0x000F, 0xC000, 
  1362.      0x7C00, 0x0E0F, 0xFFE0, 0x000F, 0xC000, 
  1363.      0x7C00, 0x07CF, 0xFEE0, 0x000F, 0xC000, 
  1364.      0x7C00, 0x00E7, 0xEEE0, 0x000F, 0xC000, 
  1365.      0x7C00, 0x0FC7, 0xE7C0, 0x000F, 0xC000, 
  1366.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1367.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1368.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1369.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1370.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1371.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1372.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1373.      0x7C00, 0x0000, 0x0000, 0x000F, 0xC000, 
  1374.      0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC000, 
  1375.      0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC000, 
  1376.      0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC000, 
  1377.      0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  1378.  
  1379.      /* BitPlane #1 */
  1380.  
  1381.      0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
  1382.      0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC000, 
  1383.      0x4000, 0x0000, 0x0000, 0x0000, 0x4000, 
  1384.      0x4000, 0x0000, 0x0000, 0x0000, 0x4000, 
  1385.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1386.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1387.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1388.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1389.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1390.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1391.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1392.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1393.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1394.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1395.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1396.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1397.      0x43FF, 0xFFFF, 0xE1FF, 0xFFF0, 0x4000, 
  1398.      0x43FF, 0xFFFF, 0xF1FF, 0xFFF0, 0x4000, 
  1399.      0x43FF, 0xF811, 0x803F, 0xFFF0, 0x4000, 
  1400.      0x43FF, 0xF1F0, 0x001F, 0xFFF0, 0x4000, 
  1401.      0x43FF, 0xF830, 0x011F, 0xFFF0, 0x4000, 
  1402.      0x43FF, 0xFF18, 0x111F, 0xFFF0, 0x4000, 
  1403.      0x43FF, 0xF038, 0x183F, 0xFFF0, 0x4000, 
  1404.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1405.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1406.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1407.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1408.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1409.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1410.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1411.      0x43FF, 0xFFFF, 0xFFFF, 0xFFF0, 0x4000, 
  1412.      0x4000, 0x0000, 0x0000, 0x0000, 0x4000, 
  1413.      0x4000, 0x0000, 0x0000, 0x0000, 0x4000, 
  1414.      0x7FFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC000, 
  1415.      0x0000, 0x0000, 0x0000, 0x0000, 0x0000
  1416.      };
  1417.  
  1418.  
  1419. struct Image               flist.icon_image = {
  1420.      0, 0, 67, 35, 2, flist.icon_data, 0x3, 0x0, NULL
  1421.      };
  1422.  
  1423. struct Image               cursor_image = {
  1424.      0, 0, 16, 9, 1, cursor_img, 0x1, 0x0, NULL
  1425.      };
  1426.  
  1427. SHAR_EOF
  1428. cat << \SHAR_EOF > flist.icon.uu
  1429.  
  1430. begin 644 flist.icon
  1431. M1D]230```M1)3$)-0DU(1````!0`0P`C``````("`0````H+`H``R$--05``(
  1432. M```,````T-"P4(#`\(!`1U)!0@````0`(0`10U).1P````@```JJ``$#`T-2P
  1433. M3D<````(```*J@`!`P%#4DY'````"```"JH``0``0U).1P````@```JJ``$`D
  1434. M`$)/1%D```)+]P#W``!_^O\!P```?_K_`<```'_Z_P'```!`^@`!0```?_K_'
  1435. M`<```$#Z``%```!\^P`"#\```$/[_P+P0```?/L``@_```!#^_\"\$``"7P?.
  1436. MYX.``8`/P```0_O_`O!```E\#N.```.`#\```$/[_P+P0``)?`X#AX?GX`_`:
  1437. M``!#^_\"\$``"7P/@X..`X`/P```0_O_`O!```E\#@.#A\.`#\```$/[_P+PY
  1438. M0``)?`X#@X#CX`_```!#^_\"\$``"7P?!\?/P<`/P```0_O_`O!```!\^P`"3
  1439. M#\```$/[_P+P0```?/L``@_```!#^_\"\$```'S[``(/P```0_O_`O!```!\H
  1440. M_@`%'@``#\```$/^_P7A___P0```?/X`!0X```_```!#_O\%\?__\$``"7P`)
  1441. M!^Y_P``/P``)0__X$8`___!```E\``X/_^``#\``"4/_\?``'__P0``)?``';
  1442. MS_[@``_```E#__@P`1__\$``"7P``.?NX``/P``)0___&!$?__!```E\``_'C
  1443. MY\``#\``"4/_\#@8/__P0```?/L``@_```!#^_\"\$```'S[``(/P```0_O_K
  1444. M`O!```!\^P`"#\```$/[_P+P0```?/L``@_```!#^_\"\$```'S[``(/P```H
  1445. M0_O_`O!```!\^P`"#\```$/[_P+P0```?/L``@_```!#^_\"\$```'S[``(/E
  1446. MP```0_O_`O!```!_^O\!P```0/H``4```'_Z_P'```!`^@`!0```?_K_`<``0
  1447. ,`'_Z_P'``/<`]P``G
  1448. ``
  1449. end
  1450. size 732
  1451. SHAR_EOF
  1452. cat << \SHAR_EOF > help.c
  1453. /* 
  1454.     This file contains the Help routine
  1455.  
  1456.     To invoke the help routine, hit the Help key!
  1457.  
  1458.     Written by Steve (Raz) Berry with help from Carol Schnepper
  1459.     (I stole the window spec and the code to wait for a keypress from
  1460.     her example program 'Timerwin.c')
  1461.  
  1462. */
  1463.  
  1464. #include "flist.h"
  1465. #include <stdio.h>
  1466.  
  1467. extern struct Screen *scrptr;
  1468.  
  1469. struct   NewWindow helpwin = {
  1470.    40,0,                                  /* LeftEdge and TopEdge */
  1471.    500, 200,                              /* Width and Height */
  1472.    -1, -1,                                /* DetailPen and BlockPen */
  1473.    CLOSEWINDOW|VANILLAKEY,                /* IDCMP Flags */
  1474.    WINDOWDEPTH|WINDOWDRAG|WINDOWCLOSE     /* Flags */
  1475.    |SMART_REFRESH|ACTIVATE,
  1476.    NULL, NULL,                            /* Gadget and Image pointers */
  1477.    "Help",                                /* Title string */
  1478.    NULL,                                  /* Screen ptr null (this screen) */
  1479.    NULL,                                  /* BitMap pointer */
  1480.    50, 20,                                /* MinWidth and MinHeight */
  1481.    320, 200,                              /* MaxWidth and MaxHeight */
  1482.    WBENCHSCREEN                           /* Type of window */
  1483.    };
  1484.  
  1485. /* Here is the text to be output */
  1486.  
  1487. char *text[] = {
  1488.         "",
  1489.         "Key        Command Description",
  1490.         "---        ------- -----------",
  1491.         "^A         bring up the ARP Filerequestor.",
  1492.         "^C         abort Flist.",
  1493.         "^D         change to current Directory.",
  1494.         "^G         re-Get the current directory.",
  1495.         "^K         delete (Kill) current file.",
  1496.         "^L         Repaint and restore screen.",
  1497.         "^N         Make directory",
  1498.         "^P         get Parent directory.",
  1499.         "^R         Rename current file or directory",
  1500.         "^S         sort list by Names.",
  1501.         "^T         sort list by Time.",
  1502.         "^Z         sort list by Size.",
  1503.         "^O         sort by Pattern (ARP wildcards).",
  1504.         "^U         Erase line.",
  1505.         "^X         Execute REXX macro.",
  1506.         " Hitting the Esc key will insert the current filename into",
  1507.         " the command line.",
  1508.         "   Hit any key or the close gadget to continue."
  1509.         };
  1510.  
  1511. Help()
  1512. {
  1513.     int i;
  1514.     struct Window *helptr;
  1515.     struct RastPort *hrp;
  1516.  
  1517.     helptr = OpenWindow(&helpwin);
  1518.     if (helptr == NULL) 
  1519.         auto_req("Couldn't open Window!");
  1520.     else {
  1521.           hrp = helptr->RPort;
  1522.         Move(hrp,10L,20L);
  1523.  
  1524.         for (i=0;i<21;i++){
  1525.             Text(hrp,text[i],strlen(text[i]));
  1526.             Move(hrp,10,i+20+8*i);
  1527.         }
  1528.  
  1529.         wait_for_event(helptr);
  1530.     }
  1531. }
  1532. SHAR_EOF
  1533. cat << \SHAR_EOF > iconify.c
  1534. /*  :ts=8 bk=0
  1535.  *
  1536.  * iconify.c:    You asked for it, you got it.
  1537.  *
  1538.  * Copyright 1987 by Leo L. Schwab.
  1539.  * Permission is hereby granted for use in any and all programs, both
  1540.  * Public Domain and commercial in nature, provided this Copyright notice
  1541.  * is left intact.  Purveyors of programs, at their option, may wish observe
  1542.  * the following conditions (in the spirit of hackerdom):
  1543.  *    1: You send me a free, registered copy of the program that uses the
  1544.  *       iconify feature,
  1545.  *    2: If you're feeling really nice, a mention in the program's
  1546.  *       documentation of my name would be neat.
  1547.  *
  1548.  *                     8712.10        (415) 456-3960
  1549.  */
  1550. #include <exec/types.h>
  1551. #include <devices/timer.h>
  1552. #include <intuition/intuition.h>
  1553. #include "icon/iconify.h"
  1554.  
  1555. /*
  1556.  * It is recommended that the tick rate not be made too rapid to avoid
  1557.  * bogging down the system.
  1558.  */
  1559. #define    TICKS_PER_SECOND    10
  1560.  
  1561. /*
  1562.  * Some programmers may not wish to have the added functionality of the
  1563.  * ICON_FUNCTION feature.  If you're such a programmer, you may comment out
  1564.  * the following #define, which will eliminate the code to handle function
  1565.  * calls, and make iconify() even smaller.
  1566.  */
  1567. #define    USE_FUNCTIONS
  1568.  
  1569. /*
  1570.  * Jim Mackraz suggested making icons easily identifiable by outside
  1571.  * programs, so this constant gets stuffed into the UserData field.
  1572.  */
  1573. #define    ICON    0x49434f4eL        /*  'ICON'  */
  1574.  
  1575.  
  1576. extern void    *OpenWindow(), *GetMsg(), *CreatePort(), *CreateExtIO(),
  1577.         *CheckIO();
  1578. extern long    OpenDevice(), DoubleClick();
  1579.  
  1580.  
  1581. static struct Gadget gadget = {
  1582.     NULL,
  1583.     0, 0, 0, 0,
  1584.     NULL,                /*  Set later  */
  1585.     GADGIMMEDIATE,
  1586.     WDRAGGING,            /*  Observe the Magic!  */
  1587.     NULL,                /*  Set later  */
  1588.     NULL, NULL, NULL, NULL,
  1589.     0, 0
  1590. };
  1591.  
  1592. static struct NewWindow windef = {
  1593.     0, 0, 0, 0,            /*  Set later  */
  1594.     -1, -1,
  1595.     GADGETDOWN,
  1596.     BORDERLESS | SMART_REFRESH | NOCAREREFRESH,
  1597.     &gadget,
  1598.     NULL, NULL, NULL, NULL,        /*  Lotsa these  */
  1599.     0, 0, 0, 0,
  1600.     WBENCHSCREEN
  1601. };
  1602.  
  1603. static struct Window        *win;
  1604.  
  1605. #ifdef USE_FUNCTIONS
  1606. static struct timerequest    *tr;
  1607. static struct MsgPort        *reply;
  1608. #endif
  1609.  
  1610.  
  1611. iconify (left, top, width, height, screen, ptr, type)
  1612. UWORD *left, *top, width, height;
  1613. struct Screen *screen;
  1614. APTR ptr;
  1615. int type;
  1616. {
  1617.     register struct IntuiMessage    *msg;
  1618.     long                secs = 0, mics = 0,
  1619.                     cs, cm,
  1620.                     class,
  1621.                     sigmask;
  1622.  
  1623.     windef.LeftEdge        = *left;
  1624.     windef.TopEdge        = *top;
  1625.     windef.Width        = width;
  1626.     windef.Height        = height;
  1627.     windef.Type = (windef.Screen = screen) ? CUSTOMSCREEN : WBENCHSCREEN;
  1628.  
  1629.     gadget.Flags        = GADGHCOMP | GRELWIDTH | GRELHEIGHT;
  1630.  
  1631.     switch (type & 3) {
  1632.     case ICON_IMAGE:
  1633.         gadget.Flags        |= GADGIMAGE;
  1634.     case ICON_BORDER:
  1635.         gadget.GadgetRender    = ptr;
  1636.         break;
  1637.  
  1638.     case ICON_FUNCTION:
  1639. #ifdef USE_FUNCTIONS
  1640.         gadget.GadgetRender    = NULL;
  1641. #else
  1642.         return (0);
  1643. #endif
  1644.         break;
  1645.  
  1646.     default:
  1647.         return (0);
  1648.     }
  1649.  
  1650.     if (!openstuff ())
  1651.         return (0);
  1652.     sigmask = 1L << win -> UserPort -> mp_SigBit;
  1653.  
  1654. #ifdef USE_FUNCTIONS
  1655.     if (type == ICON_FUNCTION) {
  1656.         sigmask |= 1L << reply -> mp_SigBit;
  1657.         tr -> tr_node.io_Command= TR_ADDREQUEST;
  1658.         tr -> tr_time.tv_secs    = 0;
  1659.         tr -> tr_time.tv_micro    = (1000000L / TICKS_PER_SECOND);
  1660.         SendIO (tr);
  1661.         /*
  1662.          * Make initialization call to user's function.
  1663.          * Isn't typecasting wonderful?  :-|
  1664.          */
  1665.         (* ((void (*)()) ptr)) (win, (WORD) 1);
  1666.     }
  1667. #endif
  1668.  
  1669.     while (1) {
  1670.         Wait (sigmask);
  1671.  
  1672. #ifdef USE_FUNCTIONS
  1673.         if (GetMsg (reply)) {
  1674.             /*
  1675.              * Call user's function to do something to the icon.
  1676.              */
  1677.             (* ((void (*)()) ptr)) (win, (WORD) 0);
  1678.             tr -> tr_time.tv_secs    = 0;
  1679.             tr -> tr_time.tv_micro    =
  1680.              (1000000L / TICKS_PER_SECOND);
  1681.             SendIO (tr);
  1682.         }
  1683. #endif
  1684.  
  1685.         if (msg = GetMsg (win -> UserPort)) {
  1686.             class = msg -> Class;
  1687.             cs = msg -> Seconds;
  1688.             cm = msg -> Micros;
  1689.             ReplyMsg (msg);
  1690.  
  1691.             if (class == GADGETDOWN) {
  1692.                 if (DoubleClick (secs, mics, cs, cm))
  1693.                     break;
  1694.                 secs = cs;  mics = cm;
  1695.             }
  1696.         }
  1697.     }
  1698.  
  1699. #ifdef USE_FUNCTIONS
  1700.     if (type == ICON_FUNCTION) {
  1701.         AbortIO (tr);
  1702.         WaitIO (tr);
  1703.     }
  1704. #endif
  1705.  
  1706.     *left = win -> LeftEdge;
  1707.     *top = win -> TopEdge;
  1708.     closestuff ();
  1709.     return (1);
  1710. }
  1711.  
  1712. static
  1713. openstuff ()
  1714. {
  1715.     if (!(win = OpenWindow (&windef)))
  1716.         return (0);
  1717.     win -> UserData = (BYTE *) ICON;
  1718.         
  1719. #ifdef USE_FUNCTIONS
  1720.     if (!(reply = CreatePort (NULL, NULL)) ||
  1721.         !(tr = CreateExtIO (reply, (long) sizeof (*tr))) ||
  1722.         OpenDevice (TIMERNAME, UNIT_VBLANK, tr, 0L)) {
  1723.         closestuff ();
  1724.         return (0);
  1725.     }
  1726. #endif
  1727.  
  1728.     return (1);
  1729. }
  1730.  
  1731. static
  1732. closestuff ()
  1733. {
  1734. #ifdef USE_FUNCTIONS
  1735.     if (tr) {
  1736.         if (tr -> tr_node.io_Device)
  1737.             CloseDevice (tr);
  1738.         DeleteExtIO (tr, (long) sizeof (*tr));
  1739.     }
  1740.     if (reply)        DeletePort (reply);
  1741. #endif
  1742.  
  1743.     if (win)        CloseWindow (win);
  1744. }
  1745. SHAR_EOF
  1746. cat << \SHAR_EOF > iconify.h
  1747. /*  :ts=8 bk=0
  1748.  *
  1749.  * iconify.h:    Should be used by all programs intending to use iconify.c.
  1750.  *
  1751.  * Copyright 1987 by Leo L. Schwab.
  1752.  * Permission is hereby granted for use in any and all programs, both
  1753.  * Public Domain and commercial in nature, provided this Copyright notice
  1754.  * is left intact.  Purveyors of programs, at their option, may wish observe
  1755.  * the following conditions (in the spirit of hackerdom):
  1756.  *    1: You send me a free, registered copy of the program that uses the
  1757.  *       iconify feature,
  1758.  *    2: If you're feeling really nice, a mention in the program's
  1759.  *       documentation of my name would be neat.
  1760.  *
  1761.  *                     8712.10        (415) 456-3960
  1762.  */
  1763.  
  1764. #define    ICON_IMAGE    0
  1765. #define    ICON_BORDER    1
  1766. #define    ICON_FUNCTION    2
  1767.  
  1768. /*  Suggested icon size for a standard (640 x 200) WorkBench screen.  */
  1769. #define    ICONWIDTH    ((UWORD) 50)
  1770. #define    ICONHEIGHT    ((UWORD) 25)
  1771. SHAR_EOF
  1772. cat << \SHAR_EOF > makefile
  1773. #
  1774. #   Makefile for Flist... Please check the flist.h file for 
  1775. #   customization.
  1776. #
  1777. #   Steve (Raz) Berry '88
  1778.  
  1779. CFLAGS    = +C +Iinclude:symbols.m -s -n 
  1780.  
  1781. OBJECTS    =    parse.o32 rexxport.o32 rexxglue.o menu.o32 arpdos.o32 \
  1782.         ttyio.o32 icon/ttyicon.o icon/iconify.o 
  1783.  
  1784. OBJECTS1 = pathname.o32 dos.o32 help.o32 display.o32 sort.o32 misc.o32
  1785.  
  1786. OTHERS    =    dh:aztec/sys2/lib/detach.o32
  1787.  
  1788. .asm.o:
  1789.         as -C -D $*.asm
  1790.  
  1791. .c.o32:
  1792.         cc +l $(CFLAGS) -o $@ $*.c
  1793.  
  1794. .c.o:
  1795.         cc +l $(CFLAGS) -o $@ icon/$*.c
  1796.  
  1797. Flist:    Flist.o32 $(OBJECTS) $(OBJECTS1)
  1798.         ln -w +cd -g Flist.o32 $(OBJECTS) $(OBJECTS1) -larp32 -lc32
  1799.  
  1800. clean:
  1801.         delete $(OBJECTS)
  1802.         delete $(OBJECTS1)
  1803.  
  1804. backup:
  1805.         copy work:Flist Flist_backup:Flist all clone
  1806.  
  1807. release:
  1808.         copy work:Flist/Flist bin:
  1809.         delete Flist_release:flist.zoo
  1810.         zoo a RAM:flist work:flist/*
  1811.         zoo D RAM:flist *.o32
  1812.         zoo a RAM:flist work:flist/icon/*
  1813.         zoo a RAM:flist work:flist/null/*
  1814.         zoo P RAM:flist
  1815.         delete RAM:flist.bak
  1816.         copy RAM:flist.zoo Flist_release:
  1817. SHAR_EOF
  1818. cat << \SHAR_EOF > misc.c
  1819. /*
  1820.     String gadgets and misc functions.
  1821.  
  1822.     Written by: Steve (Raz) Berry
  1823. */
  1824.  
  1825. #include "flist.h"
  1826.  
  1827. char strbuf[256];
  1828. char undo[256];
  1829.  
  1830. struct IntuiText AutoText = {
  1831.    REDP,     WHTP,
  1832.    JAM2,  15,
  1833.    5,    NL,
  1834.    " Flist ", NULL
  1835. };
  1836.  
  1837. /** TRUE TEXT **/
  1838. struct IntuiText TRUEtext = {
  1839.    BLUP,  WHTP,
  1840.    JAM2,
  1841.    7,                       /* LeftEdge */
  1842.    3,                       /* TopEdge  */
  1843.    NL,                      /* Default font */
  1844.    "OK",                    /* Text */
  1845.    NL                       /* No pointer to next text */
  1846. };
  1847.  
  1848. /** FALSE TEXT **/
  1849. struct IntuiText FALSEtext = {
  1850.    REDP,  WHTP,
  1851.    JAM2,
  1852.     7,                       /* LeftEdge */
  1853.     3,                       /* TopEdge  */
  1854.    NL,                       /* Default font */
  1855.    "NO!",                    /* Text */
  1856.    NL
  1857. };
  1858.  
  1859. struct StringInfo strinfo = {
  1860.     strbuf,
  1861.     undo,
  1862.     0,
  1863.     200,
  1864.     0, 0,
  1865.     0, 0,
  1866.     0, 0,
  1867.     0, 0,
  1868.     0
  1869. };
  1870.     
  1871. struct Gadget str = {
  1872.     NULL,
  1873.     20, 20, 240, 10,
  1874.     GADGHCOMP,
  1875.     GADGIMMEDIATE|RELVERIFY,
  1876.     STRGADGET,
  1877.     NULL,
  1878.     NULL,
  1879.     NULL,
  1880.     NULL,
  1881.     (APTR)&strinfo,
  1882.     0, NULL
  1883. };
  1884.  
  1885. struct  NewWindow strwin = {
  1886.    140,70,                                /* LeftEdge and TopEdge */
  1887.    300, 40,                               /* Width and Height */
  1888.    0, 1,                                  /* DetailPen and BlockPen */
  1889.    CLOSEWINDOW|GADGETUP,                  /* IDCMP Flags */
  1890.    WINDOWDEPTH|WINDOWDRAG|WINDOWCLOSE     /* Flags */
  1891.    |SMART_REFRESH|ACTIVATE,
  1892.    &str, NULL,                            /* Gadget and Image pointers */
  1893.    NULL,                                  /* Title string */
  1894.    NULL,                                  /* Screen ptr null (this screen) */
  1895.    NULL,                                  /* BitMap pointer */
  1896.    50, 20,                                /* MinWidth and MinHeight */
  1897.    320, 200,                              /* MaxWidth and MaxHeight */
  1898.    WBENCHSCREEN                           /* Type of window */
  1899. };
  1900.  
  1901. /* Make a string gadget in it's own window */
  1902.  
  1903. struct Window *make_gadget(title)
  1904. char *title;
  1905. {
  1906.     struct Window *strptr;
  1907.  
  1908.     strwin.Title = title;
  1909.     strptr = OpenWindow(&strwin);
  1910.  
  1911.     if(strptr != NULL) {
  1912.         RefreshGadgets(&str, strptr, NULL);
  1913.         ActivateGadget(&str, strptr, NULL);
  1914.     }
  1915.     return strptr;
  1916. }
  1917.  
  1918. /* Wait for one event from a window, then return */
  1919.  
  1920. wait_for_event(win)
  1921. struct Window *win;
  1922. {
  1923.     ULONG imask,signals;
  1924.     struct IntuiMessage *imsg;
  1925.  
  1926.     imask = 1 << win->UserPort->mp_SigBit;
  1927.  
  1928.     signals = Wait(imask);
  1929.  
  1930.     if(signals & imask) {
  1931.         while(imsg = (struct IntuiMessage *)GetMsg(win->UserPort))
  1932.             ReplyMsg(imsg);
  1933.     } 
  1934.     if (win) {
  1935.         while(imsg = (struct IntuiMessage *)GetMsg(win->UserPort))
  1936.             ReplyMsg(imsg);
  1937.         CloseWindow(win);
  1938.     }
  1939. }
  1940.  
  1941. int auto_req();
  1942. /***************************************************************************
  1943.                             HANDLE AUTO-REQUESTS
  1944. ***************************************************************************/
  1945. int auto_req (text)
  1946. char *text;         /* Pointer to the text */
  1947. {
  1948.     struct Process *proc;
  1949.     int   val, temp;
  1950.  
  1951.     AutoText.IText = text;               /* Text pointer          */
  1952.  
  1953.     temp = ((CHARW + 1) * strlen(text)) + (4 * CHARW);
  1954.     temp = (temp < 150) ? 150: temp;
  1955.  
  1956.     proc = (struct Process *)FindTask(NULL);
  1957.     val = AutoRequest(proc->pr_WindowPtr, &AutoText, &TRUEtext, &FALSEtext, 
  1958.             0L, 0L, (LONG)temp, 60L );
  1959.     return val;
  1960. }
  1961. SHAR_EOF
  1962. #    End of shell archive
  1963. exit 0
  1964. -- 
  1965. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  1966. Have five nice days.
  1967.